// store/cart.js
import { defineStore } from 'pinia';
import { useUserStore } from './user';
import http from '@/utils/http/http.js';

// #ifdef H5 || APP-PLUS || MP-WEIXIN || MP-ALIPAY || MP-BAIDU || MP-QQ || MP-TOUTIAO || MP-LARK
// const uni = typeof uni !== 'undefined' ? uni : {};
// #endif

export const useCartStore = defineStore('cart', {
  state: () => ({
    cartItems: [],
    loading: false,
    cartCount: 0
  }),
  
  getters: {
    // 计算是否全选
    isAllSelected: (state) => {
      if (state.cartItems.length === 0) return false;
      return state.cartItems.every(item => item.selected === 1);
    },
    
    // 计算选中商品数量
    selectedItemCount: (state) => {
      return state.cartItems.filter(item => item.selected === 1).length;
    },
    
    // 计算选中商品总价
    selectedTotalPrice: (state) => {
      return state.cartItems
        .filter(item => item.selected === 1)
        .reduce((total, item) => total + parseFloat(item.price) * item.quantity, 0)
        .toFixed(2);
    }
  },
  
  actions: {
    // 获取购物车列表
    async fetchCartList() {
      const userStore = useUserStore();
      
      // 如果用户未登录，则清空购物车
      if (!userStore.isLoggedIn) {
        this.cartItems = [];
        return;
      }
      
      this.loading = true;
      
      try {
        // 从本地存储获取购物车数据
        const cartData = uni.getStorageSync('cartItems');
        if (cartData) {
          try {
            this.cartItems = JSON.parse(cartData);
            console.log('从本地存储获取购物车数据:', this.cartItems);
          } catch (e) {
            console.error('解析购物车数据失败:', e);
            this.cartItems = [];
          }
        }
        
        // 这里将来可以替换为后端API调用
        // const response = await http.get('/api/cart/list');
        // if (response.code === 200 && response.data) {
        //   this.cartItems = response.data;
        // }
      } catch (error) {
        console.error('获取购物车列表失败:', error);
        uni.showToast({
          title: '获取购物车失败，请重试',
          icon: 'none'
        });
      } finally {
        this.loading = false;
      }
    },
    
    // 添加商品到购物车
    async addToCart(product, quantity = 1) {
      const userStore = useUserStore();
      
      // 检查用户是否登录
      if (!userStore.isLoggedIn) {
        uni.showToast({
          title: '请先登录',
          icon: 'none'
        });
        return false;
      }
      
      // 检查商品状态和库存
      if (product.status === 0) {
        uni.showToast({
          title: '该商品已下架',
          icon: 'none'
        });
        return false;
      }
      
      if (product.totalStock <= 0) {
        uni.showToast({
          title: '该商品库存不足',
          icon: 'none'
        });
        return false;
      }
      
      try {
        // 查找购物车中是否已存在该商品
        const existingItemIndex = this.cartItems.findIndex(item => item.productId === product.id);
        
        if (existingItemIndex !== -1) {
          // 如果已存在，则增加数量
          this.cartItems[existingItemIndex].quantity += quantity;
          
          // 检查是否超过库存
          if (this.cartItems[existingItemIndex].quantity > product.totalStock) {
            this.cartItems[existingItemIndex].quantity = product.totalStock;
            uni.showToast({
              title: '已达到最大库存',
              icon: 'none'
            });
          }
        } else {
          // 如果不存在，则添加新商品
          const cartItem = {
            userId: userStore.userInfo ? userStore.userInfo.id : 0,
            productId: product.id,
            quantity: quantity,
            selected: 1, // 默认选中
            // 以下是前端展示需要的额外字段，不会发送到后端
            name: product.name,
            price: product.price,
            mainImageUrl: product.mainImageUrl,
            status: product.status,
            totalStock: product.totalStock,
            spec: product.spec || ''
          };
          
          this.cartItems.push(cartItem);
        }
        
        // 保存到本地存储
        try {
          uni.setStorageSync('cartItems', JSON.stringify(this.cartItems));
        } catch (e) {
          console.error('保存购物车到本地存储失败:', e);
        }
        
        // 更新购物车数量
        this.getCartCount();
        
        // 这里将来可以替换为后端API调用
        // const response = await http.post('/api/cart/add', {
        //   productId: product.id,
        //   quantity: quantity,
        //   selected: 1
        // });
        
        uni.showToast({
          title: '已加入购物车',
          icon: 'success'
        });
        
        return true;
      } catch (error) {
        console.error('添加购物车失败:', error);
        uni.showToast({
          title: '添加购物车失败，请重试',
          icon: 'none'
        });
        return false;
      }
    },
    
    // 更新购物车商品数量
    async updateCartItemQuantity(productId, quantity) {
      try {
        const index = this.cartItems.findIndex(item => item.productId === productId);
        if (index !== -1) {
          this.cartItems[index].quantity = quantity;
          
          // 保存到本地存储
          try {
            uni.setStorageSync('cartItems', JSON.stringify(this.cartItems));
          } catch (e) {
            console.error('保存购物车到本地存储失败:', e);
          }
          
          // 这里将来可以替换为后端API调用
          // await http.post('/api/cart/update', {
          //   productId: productId,
          //   quantity: quantity
          // });
          
          return true;
        }
        return false;
      } catch (error) {
        console.error('更新购物车数量失败:', error);
        return false;
      }
    },
    
    // 移除购物车商品
    async removeCartItem(productId) {
      try {
        const index = this.cartItems.findIndex(item => item.productId === productId);
        if (index !== -1) {
          this.cartItems.splice(index, 1);
          
          // 保存到本地存储
          try {
            uni.setStorageSync('cartItems', JSON.stringify(this.cartItems));
          } catch (e) {
            console.error('保存购物车到本地存储失败:', e);
          }
          
          // 更新购物车数量
          this.getCartCount();
          
          // 这里将来可以替换为后端API调用
          // await http.post('/api/cart/remove', {
          //   productId: productId
          // });
          
          return true;
        }
        return false;
      } catch (error) {
        console.error('删除购物车商品失败:', error);
        return false;
      }
    },
    
    // 切换商品选中状态
    async toggleItemSelected(productId, selected) {
      try {
        const index = this.cartItems.findIndex(item => item.productId === productId);
        if (index !== -1) {
          this.cartItems[index].selected = selected ? 1 : 0;
          
          // 保存到本地存储
          try {
            uni.setStorageSync('cartItems', JSON.stringify(this.cartItems));
          } catch (e) {
            console.error('保存购物车到本地存储失败:', e);
          }
          
          // 这里将来可以替换为后端API调用
          // await http.post('/api/cart/toggle-select', {
          //   productId: productId,
          //   selected: selected ? 1 : 0
          // });
          
          return true;
        }
        return false;
      } catch (error) {
        console.error('切换商品选中状态失败:', error);
        return false;
      }
    },
    
    // 切换全选状态
    async toggleAllSelected(selected) {
      try {
        this.cartItems.forEach(item => {
          item.selected = selected ? 1 : 0;
        });
        
        // 保存到本地存储
        try {
          uni.setStorageSync('cartItems', JSON.stringify(this.cartItems));
        } catch (e) {
          console.error('保存购物车到本地存储失败:', e);
        }
        
        // 这里将来可以替换为后端API调用
        // await http.post('/api/cart/toggle-all', {
        //   selected: selected ? 1 : 0
        // });
        
        return true;
      } catch (error) {
        console.error('切换全选状态失败:', error);
        return false;
      }
    },
    
    // 清空购物车
    async clearCart() {
      try {
        this.cartItems = [];
        
        // 清除本地存储
        try {
          uni.removeStorageSync('cartItems');
        } catch (e) {
          console.error('清除购物车本地存储失败:', e);
        }
        
        // 更新购物车数量
        this.getCartCount();
        
        // 这里将来可以替换为后端API调用
        // await http.post('/api/cart/clear');
        
        return true;
      } catch (error) {
        console.error('清空购物车失败:', error);
        return false;
      }
    },
    
    // 获取购物车商品数量
    getCartCount() {
      const count = this.cartItems.reduce((total, item) => total + item.quantity, 0);
      this.cartCount = count;
      return count;
    }
  }
});